package cn.ffcs.base.service;

import java.util.Date;
import java.util.List;

import org.hibernate.criterion.Criterion;

import cn.ffcs.base.dao.IBaseDAO;
import cn.ffcs.base.model.BaseEntity;
import cn.ffcs.base.web.PageControl;
import cn.ffcs.security.model.User;
import cn.ffcs.util.context.ApplicationContextUtil;
import cn.ffcs.util.ext.Expression;

/**
 * 
 * 服务层基本类实现<br/> <table>
 * <tr>
 * <td>负责人/principal: </td>
 * <td colspan="2">liuzhh</td>
 * <tr>
 * <td>修改记录/revision:</td>
 * <td colspan="2"></td>
 * </tr>
 * <tr>
 * <td>日期:</td>
 * <td>修改人:</td>
 * <td>修改说明:</td>
 * </tr>
 * <tr>
 * <td></td>
 * <td></td>
 * <td></td>
 * </tr>
 * </table>
 * @author liuzhh
 * @version $Id$
 */
public class BaseService<B extends BaseEntity> implements IBaseService<B>
{

    private IBaseDAO<B> baseDAO;
    
    /**
     * 设置实体基本信息:
     *     包括创建人,开始时间,结束时间
     * @param baseEntity
     */
    protected void setBaseInfo(BaseEntity baseEntity){
        User currUser=ApplicationContextUtil.getUserContextObject().getCurrUser();
        if (currUser!=null)
        baseEntity.setCreator(currUser.getUserID());
        //设置有效时间
        baseEntity.setBegin(baseDAO.getCurrSysdate());
        Long l=Long.valueOf("9783941568000");
        Date end=new Date(l);
        baseEntity.setEnd(end);
    }

    /**
     * 新增或修改操作
     * @param baseEntity
     */
    public void saveOrUpdate(B baseEntity)
    {
        if (baseEntity != null)
        {
            if (baseEntity.getId() == null || baseEntity.getId() == 0)
            {   
                //设置操作人
                User currUser=ApplicationContextUtil.getUserContextObject().getCurrUser();
                if (currUser!=null)
                baseEntity.setCreator(currUser.getUserID());
                //设置有效时间
                baseEntity.setBegin(baseDAO.getCurrSysdate());
                Long l=Long.valueOf("9783941568000");
                Date end=new Date(l);
                baseEntity.setEnd(end);
                //保存数据
                baseDAO.save(baseEntity);
            }
            else
            {
                baseDAO.update(baseEntity);
            }
        }
    }
    public void merge(B baseEntity){
        baseDAO.merge(baseEntity);
    }
    
    /**
     * 
     * 保存操作
     * @param baseEntity
     */
    public void save(B baseEntity){
        baseDAO.save(baseEntity);
    }

    /**
     * 
     * 更新操作
     * @param baseEntity
     */
    public void update(B baseEntity){
        baseDAO.update(baseEntity);
    }

    /**
     * 删除操作
     * @param baseEntity
     */
    public void remove(B baseEntity)
    {
        if (baseEntity != null && baseEntity.getId() != 0)
        {
            baseEntity = findById(baseEntity.getId());
            if (baseEntity != null)
            {
                //获取当前时间
                Date curr=getCurrSysdate();
                baseEntity.setEnd(curr);
                update(baseEntity);
                //baseDAO.delete(baseEntity);
            }
        }
    }
    
    /**
     * 批量删除
     * @param ids
     */
    public void batchDel(String[] ids){
        if (ids != null && ids.length > 0)
        {
            for (String id : ids)
            {
                //逻辑删除
                B b=(B)findById(Integer.parseInt(id));
                remove(b);
//                baseDAO.deleteById(id);
            }
        }
    }
    
    /**
     * 批量删除
     * @param ids
     */
    public void deleteBy(Object entity, String param, String paramValue){
        baseDAO.delete(entity, param, paramValue);
    }
    
    /**
     * 根据id得到业务实体
     * @param id
     * @return
     */
    public B findById(Integer id)
    {
        return (B) baseDAO.findById(id);
    }
    
    /**
     * 
     * 初始化业务数据
     * @return
     */
    public void init(){ 
    }
    
    /**
     * 获取所有关联实体
     * @return
     */
    public List<B> findAll()
    {
        return baseDAO.findAll();
    }
    
    /**
     * 
     * 取一定数据
     * @param num
     * @return
     */
    public List<B> findAll(int num,final String orderParam){
        return baseDAO.findAll(num,orderParam);  
    }
    
    /**
     * 按查询条件获取总数
     * @return
     */
    public List<B> findBy(Criterion cond){
        return baseDAO.findBy(cond);
    }
    
    /**
     * 
     * 按查询条件获取总数并按照排序字段进行排序
     * @return
     */
    @SuppressWarnings("unchecked")
    public List<B> findByAndOrder(Criterion cond,String orderParam,String strOrder){
       return baseDAO.findByAndOrder(cond, orderParam, strOrder);
    }
    
    /**
     * 获取所有同类实体数据并实现翻页
     * @param currPage
     * @param pageSize
     * @return
     */
    public PageControl findAllByPage(int currPage, int pageSize){
        return baseDAO.findAllByPage(currPage, pageSize);
    }
    
    /**
     * 得到分页数据
     * @return
     */
    public PageControl findByPage(Criterion cond,int currPage, int pageSize){
        return baseDAO.findByPage(cond, currPage, pageSize);
    }
    public PageControl findByPage(Expression exp,int currPage, int pageSize){
        return baseDAO.findByPage(exp, currPage, pageSize); 
    }
    /**
     * 
     * 得到数据库当前时间
     * @return
     */
    public Date getCurrSysdate(){
        return baseDAO.getCurrSysdate();
    }
    
    /**
     * 获取数据库中seq的nextval
     * @param sequenceName
     * @return
     */
    public String getNextval(String seqName){
        return baseDAO.getNextval(seqName);
    }
    
    /**
     * 注入DAO
     * @param baseDAO
     */
    public void setBaseDAO(IBaseDAO<B> baseDAO)
    {
        this.baseDAO = baseDAO;
    }
    
}
